import type { Question } from '@/types/exam';

/**
 * 高级特性题目（初级10道 + 中级10道 + 高级10道）
 */
export const advancedQuestions: Question[] = [
	// ========== 初级题目（10道） ==========
	{
		id: 4001,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: '高级特性',
		question: 'try-catch-finally中，以下说法正确的是？',
		options: [
			{ key: 'A', text: 'finally块可以省略' },
			{ key: 'B', text: 'catch块可以有多个' },
			{ key: 'C', text: 'try块后必须有catch块' },
			{ key: 'D', text: 'finally块中的代码不一定会执行' }
		],
		answer: ['B'],
		explanation: 'catch块可以有多个，用于捕获不同类型的异常。finally块可以省略，try块后可以只有finally而没有catch。finally块中的代码一定会执行（除非JVM崩溃）。'
	},
	{
		id: 4002,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: '高级特性',
		question: 'Java中，以下哪个关键字用于创建线程？',
		options: [
			{ key: 'A', text: 'new' },
			{ key: 'B', text: 'thread' },
			{ key: 'C', text: 'run' },
			{ key: 'D', text: 'start' }
		],
		answer: ['A'],
		explanation: '使用new关键字创建Thread对象，然后调用start()方法启动线程。继承Thread类或实现Runnable接口都可以创建线程。'
	},
	{
		id: 4003,
		techId: 'java',
		type: 'judge',
		difficulty: 'easy',
		category: '高级特性',
		question: 'Java中，线程可以通过继承Thread类或实现Runnable接口来创建。',
		options: [
			{ key: 'A', text: '正确' },
			{ key: 'B', text: '错误' }
		],
		answer: ['A'],
		explanation: '创建线程有两种方式：1. 继承Thread类，重写run()方法；2. 实现Runnable接口，实现run()方法。推荐使用Runnable接口，因为Java只支持单继承。'
	},
	{
		id: 4004,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: '高级特性',
		question: 'Java中，以下哪个是检查异常（Checked Exception）？',
		options: [
			{ key: 'A', text: 'RuntimeException' },
			{ key: 'B', text: 'IOException' },
			{ key: 'C', text: 'NullPointerException' },
			{ key: 'D', text: 'ArrayIndexOutOfBoundsException' }
		],
		answer: ['B'],
		explanation: '检查异常（Checked Exception）必须被处理（try-catch或throws），如IOException、SQLException。RuntimeException及其子类是非检查异常（Unchecked Exception）。'
	},
	{
		id: 4005,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: '高级特性',
		question: 'Java中，以下哪个用于同步代码块？',
		options: [
			{ key: 'A', text: 'synchronized' },
			{ key: 'B', text: 'volatile' },
			{ key: 'C', text: 'final' },
			{ key: 'D', text: 'static' }
		],
		answer: ['A'],
		explanation: 'synchronized关键字用于同步代码块或方法，保证线程安全。volatile只保证可见性和有序性，不保证原子性。'
	},
	{
		id: 4006,
		techId: 'java',
		type: 'judge',
		difficulty: 'easy',
		category: '高级特性',
		question: 'Java中，反射可以在运行时获取类的信息。',
		options: [
			{ key: 'A', text: '正确' },
			{ key: 'B', text: '错误' }
		],
		answer: ['A'],
		explanation: '反射（Reflection）允许程序在运行时获取类的信息（类名、方法、字段等），并可以动态创建对象、调用方法、访问字段。'
	},
	{
		id: 4007,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: '高级特性',
		question: 'Java中，以下哪个用于获取类的Class对象？',
		options: [
			{ key: 'A', text: 'Class.forName()' },
			{ key: 'B', text: '类名.class' },
			{ key: 'C', text: '对象.getClass()' },
			{ key: 'D', text: '以上都可以' }
		],
		answer: ['D'],
		explanation: '获取Class对象有三种方式：1. Class.forName("类名")；2. 类名.class；3. 对象.getClass()。三种方式都可以获取Class对象。'
	},
	{
		id: 4008,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: '高级特性',
		question: 'Java中，以下哪个关于注解（Annotation）的说法是正确的？',
		options: [
			{ key: 'A', text: '注解只能用于类' },
			{ key: 'B', text: '注解可以用于类、方法、字段等' },
			{ key: 'C', text: '注解不能有参数' },
			{ key: 'D', text: '注解不能自定义' }
		],
		answer: ['B'],
		explanation: '注解可以用于类、方法、字段、参数等。注解可以定义参数，可以自定义注解（使用@interface）。注解是Java的元数据机制。'
	},
	{
		id: 4009,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: '高级特性',
		question: 'Java中，以下哪个关于泛型的说法是正确的？',
		options: [
			{ key: 'A', text: '泛型只在编译时有效，运行时会被擦除' },
			{ key: 'B', text: '泛型可以用于基本类型' },
			{ key: 'C', text: 'List<String>和List<Object>是兼容的' },
			{ key: 'D', text: '泛型不能使用通配符' }
		],
		answer: ['A'],
		explanation: 'Java泛型使用类型擦除，编译时检查类型，运行时擦除。泛型不能用于基本类型，List<String>和List<Object>不兼容，可以使用通配符？。'
	},
	{
		id: 4010,
		techId: 'java',
		type: 'judge',
		difficulty: 'easy',
		category: '高级特性',
		question: 'Java中，线程的run()方法和start()方法都可以启动线程。',
		options: [
			{ key: 'A', text: '正确' },
			{ key: 'B', text: '错误' }
		],
		answer: ['B'],
		explanation: '只有start()方法可以启动线程，它会创建新线程并调用run()方法。直接调用run()方法不会创建新线程，只是在当前线程中执行run()方法。'
	},

	// ========== 中级题目（10道） ==========
	{
		id: 4011,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: '高级特性',
		question: 'Java中，以下哪个关于synchronized的说法是正确的？',
		options: [
			{ key: 'A', text: 'synchronized只能用于方法' },
			{ key: 'B', text: 'synchronized可以用于方法和代码块' },
			{ key: 'C', text: 'synchronized只能用于实例方法' },
			{ key: 'D', text: 'synchronized不能用于静态方法' }
		],
		answer: ['B'],
		explanation: 'synchronized可以用于实例方法、静态方法和代码块。实例方法锁的是对象，静态方法锁的是类，代码块可以指定锁对象。'
	},
	{
		id: 4012,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: '高级特性',
		question: 'Java中，以下哪个关于线程池的说法是正确的？',
		options: [
			{ key: 'A', text: '线程池不能复用线程' },
			{ key: 'B', text: '线程池可以复用线程，提高性能' },
			{ key: 'C', text: '线程池只能创建固定数量的线程' },
			{ key: 'D', text: '线程池不能控制线程数量' }
		],
		answer: ['B'],
		explanation: '线程池可以复用线程，避免频繁创建和销毁线程的开销，提高性能。线程池可以控制线程数量，支持固定线程数、可扩展线程数等多种策略。'
	},
	{
		id: 4013,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: '高级特性',
		question: 'Java中，以下哪个关于异常继承的说法是正确的？',
		options: [
			{ key: 'A', text: '所有异常都继承自Exception' },
			{ key: 'B', text: '所有异常都继承自Throwable' },
			{ key: 'C', text: '所有异常都继承自Error' },
			{ key: 'D', text: '异常没有继承关系' }
		],
		answer: ['B'],
		explanation: '所有异常都继承自Throwable。Throwable有两个子类：Error（错误）和Exception（异常）。Exception又分为RuntimeException（非检查异常）和其他异常（检查异常）。'
	},
	{
		id: 4014,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: '高级特性',
		question: 'Java中，以下哪个关于Lock和synchronized的说法是正确的？',
		options: [
			{ key: 'A', text: 'Lock只能用于方法' },
			{ key: 'B', text: 'Lock提供更灵活的锁机制，可以尝试获取锁、超时等' },
			{ key: 'C', text: 'Lock性能不如synchronized' },
			{ key: 'D', text: 'Lock不能释放锁' }
		],
		answer: ['B'],
		explanation: 'Lock接口（如ReentrantLock）提供比synchronized更灵活的锁机制，支持尝试获取锁（tryLock）、超时获取锁、公平锁等。Lock需要手动释放锁。'
	},
	{
		id: 4015,
		techId: 'java',
		type: 'multiple',
		difficulty: 'medium',
		category: '高级特性',
		question: '以下哪些是Java的线程状态？',
		options: [
			{ key: 'A', text: 'NEW（新建）' },
			{ key: 'B', text: 'RUNNABLE（可运行）' },
			{ key: 'C', text: 'BLOCKED（阻塞）' },
			{ key: 'D', text: 'TERMINATED（终止）' }
		],
		answer: ['A', 'B', 'C', 'D'],
		explanation: 'Java线程有6种状态：NEW（新建）、RUNNABLE（可运行）、BLOCKED（阻塞）、WAITING（等待）、TIMED_WAITING（超时等待）、TERMINATED（终止）。'
	},
	{
		id: 4016,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: '高级特性',
		question: 'Java中，以下哪个关于反射性能的说法是正确的？',
		options: [
			{ key: 'A', text: '反射性能优于直接调用' },
			{ key: 'B', text: '反射性能低于直接调用，但提供灵活性' },
			{ key: 'C', text: '反射性能与直接调用相同' },
			{ key: 'D', text: '反射不能调用方法' }
		],
		answer: ['B'],
		explanation: '反射性能低于直接调用，因为需要在运行时解析类的信息。但反射提供了灵活性，可以在运行时动态操作类、方法、字段等。'
	},
	{
		id: 4017,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: '高级特性',
		question: 'Java中，以下哪个关于线程通信的说法是正确的？',
		options: [
			{ key: 'A', text: '线程只能通过共享变量通信' },
			{ key: 'B', text: '线程可以通过wait()、notify()、notifyAll()进行通信' },
			{ key: 'C', text: '线程不能通信' },
			{ key: 'D', text: '线程只能通过synchronized通信' }
		],
		answer: ['B'],
		explanation: '线程通信方式包括：wait()、notify()、notifyAll()（必须在synchronized块中使用）、共享变量、Lock的Condition、BlockingQueue等。'
	},
	{
		id: 4018,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: '高级特性',
		question: 'Java中，以下哪个关于原子类的说法是正确的？',
		options: [
			{ key: 'A', text: 'AtomicInteger使用synchronized保证原子性' },
			{ key: 'B', text: 'AtomicInteger使用CAS（Compare-And-Swap）保证原子性' },
			{ key: 'C', text: '原子类性能不如synchronized' },
			{ key: 'D', text: '原子类不能用于并发编程' }
		],
		answer: ['B'],
		explanation: 'AtomicInteger等原子类使用CAS（Compare-And-Swap）机制保证原子性，性能优于synchronized。原子类适合简单的原子操作，如计数器。'
	},
	{
		id: 4019,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: '高级特性',
		question: 'Java中，以下哪个关于线程死锁的说法是正确的？',
		options: [
			{ key: 'A', text: '死锁是正常现象' },
			{ key: 'B', text: '死锁是多个线程相互等待对方释放锁的情况' },
			{ key: 'C', text: '死锁不会影响程序运行' },
			{ key: 'D', text: '死锁无法避免' }
		],
		answer: ['B'],
		explanation: '死锁是多个线程相互等待对方释放锁，导致程序无法继续执行的情况。死锁可以通过避免循环等待、按顺序获取锁等方式预防。'
	},
	{
		id: 4020,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: '高级特性',
		question: 'Java中，以下哪个关于泛型通配符的说法是正确的？',
		options: [
			{ key: 'A', text: '? extends T表示上界通配符' },
			{ key: 'B', text: '? super T表示下界通配符' },
			{ key: 'C', text: '?表示无界通配符' },
			{ key: 'D', text: '以上都对' }
		],
		answer: ['D'],
		explanation: '泛型通配符包括：? extends T（上界通配符，只能读取，不能写入）、? super T（下界通配符，只能写入，不能读取）、?（无界通配符）。'
	},

	// ========== 高级题目（10道） ==========
	{
		id: 4021,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: '高级特性',
		question: 'volatile关键字的作用是？',
		options: [
			{ key: 'A', text: '保证原子性' },
			{ key: 'B', text: '保证可见性和有序性' },
			{ key: 'C', text: '替代synchronized' },
			{ key: 'D', text: '提高性能' }
		],
		answer: ['B'],
		explanation: 'volatile关键字保证变量的可见性和有序性，但不保证原子性。它禁止指令重排序，确保一个线程修改的值能被其他线程立即看到。'
	},
	{
		id: 4022,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: '高级特性',
		question: 'Java中，以下哪个关于CAS（Compare-And-Swap）的说法是正确的？',
		options: [
			{ key: 'A', text: 'CAS是乐观锁，不需要加锁' },
			{ key: 'B', text: 'CAS通过比较和交换保证原子性' },
			{ key: 'C', text: 'CAS可能产生ABA问题' },
			{ key: 'D', text: '以上都对' }
		],
		answer: ['D'],
		explanation: 'CAS是乐观锁机制，通过比较当前值和期望值，如果相等则更新为新值，保证原子性。CAS不需要加锁，但可能产生ABA问题（值被修改后又改回原值）。'
	},
	{
		id: 4023,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: '高级特性',
		question: 'Java中，以下哪个关于线程池参数的说法是正确的？',
		options: [
			{ key: 'A', text: 'corePoolSize是核心线程数' },
			{ key: 'B', text: 'maximumPoolSize是最大线程数' },
			{ key: 'C', text: 'keepAliveTime是线程空闲时间' },
			{ key: 'D', text: '以上都对' }
		],
		answer: ['D'],
		explanation: '线程池参数包括：corePoolSize（核心线程数）、maximumPoolSize（最大线程数）、keepAliveTime（线程空闲时间）、workQueue（工作队列）、threadFactory（线程工厂）、handler（拒绝策略）。'
	},
	{
		id: 4024,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: '高级特性',
		question: 'Java中，以下哪个关于CountDownLatch的说法是正确的？',
		options: [
			{ key: 'A', text: 'CountDownLatch是计数器，只能使用一次' },
			{ key: 'B', text: 'CountDownLatch用于等待多个线程完成' },
			{ key: 'C', text: 'CountDownLatch可以重复使用' },
			{ key: 'D', text: 'CountDownLatch不能用于线程同步' }
		],
		answer: ['B'],
		explanation: 'CountDownLatch是计数器，用于等待多个线程完成。一个线程等待其他线程，当计数器减为0时，等待的线程继续执行。CountDownLatch只能使用一次。'
	},
	{
		id: 4025,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: '高级特性',
		question: 'Java中，以下哪个关于CyclicBarrier的说法是正确的？',
		options: [
			{ key: 'A', text: 'CyclicBarrier只能使用一次' },
			{ key: 'B', text: 'CyclicBarrier可以重复使用，用于多线程同步' },
			{ key: 'C', text: 'CyclicBarrier不能指定屏障操作' },
			{ key: 'D', text: 'CyclicBarrier只能用于两个线程' }
		],
		answer: ['B'],
		explanation: 'CyclicBarrier可以重复使用，用于多线程同步。当指定数量的线程到达屏障时，执行屏障操作，然后所有线程继续执行。CyclicBarrier可以指定屏障操作（Runnable）。'
	},
	{
		id: 4026,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: '高级特性',
		question: 'Java中，以下哪个关于Semaphore的说法是正确的？',
		options: [
			{ key: 'A', text: 'Semaphore是信号量，用于控制访问资源的线程数' },
			{ key: 'B', text: 'Semaphore只能允许一个线程访问' },
			{ key: 'C', text: 'Semaphore不能用于限流' },
			{ key: 'D', text: 'Semaphore性能不如synchronized' }
		],
		answer: ['A'],
		explanation: 'Semaphore是信号量，用于控制同时访问资源的线程数。可以用于限流、资源池等场景。Semaphore可以允许多个线程访问，也可以只允许一个（类似synchronized）。'
	},
	{
		id: 4027,
		techId: 'java',
		type: 'multiple',
		difficulty: 'hard',
		category: '高级特性',
		question: '以下哪些是Java并发工具类？',
		options: [
			{ key: 'A', text: 'CountDownLatch' },
			{ key: 'B', text: 'CyclicBarrier' },
			{ key: 'C', text: 'Semaphore' },
			{ key: 'D', text: 'Exchanger' }
		],
		answer: ['A', 'B', 'C', 'D'],
		explanation: 'Java并发工具类包括：CountDownLatch（计数器）、CyclicBarrier（屏障）、Semaphore（信号量）、Exchanger（交换器）、Phaser（阶段器）等。'
	},
	{
		id: 4028,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: '高级特性',
		question: 'Java中，以下哪个关于ThreadLocal的说法是正确的？',
		options: [
			{ key: 'A', text: 'ThreadLocal是线程共享的' },
			{ key: 'B', text: 'ThreadLocal是线程私有的，每个线程有自己的副本' },
			{ key: 'C', text: 'ThreadLocal不能存储数据' },
			{ key: 'D', text: 'ThreadLocal性能不如共享变量' }
		],
		answer: ['B'],
		explanation: 'ThreadLocal是线程私有的，每个线程有自己的变量副本，互不干扰。适合用于线程上下文传递，避免线程安全问题。需要注意内存泄漏问题。'
	},
	{
		id: 4029,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: '高级特性',
		question: 'Java中，以下哪个关于反射访问私有成员的说法是正确的？',
		options: [
			{ key: 'A', text: '反射不能访问私有成员' },
			{ key: 'B', text: '反射可以通过setAccessible(true)访问私有成员' },
			{ key: 'C', text: '反射只能访问public成员' },
			{ key: 'D', text: '反射不能调用私有方法' }
		],
		answer: ['B'],
		explanation: '反射可以通过setAccessible(true)方法绕过访问控制，访问私有成员（字段、方法、构造函数）。这破坏了封装性，但提供了灵活性。'
	},
	{
		id: 4030,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: '高级特性',
		question: 'Java中，以下哪个关于泛型擦除的说法是正确的？',
		options: [
			{ key: 'A', text: '泛型擦除发生在编译时' },
			{ key: 'B', text: '泛型擦除发生在运行时，编译时保留类型信息' },
			{ key: 'C', text: '泛型不会擦除' },
			{ key: 'D', text: '泛型擦除只影响方法' }
		],
		answer: ['B'],
		explanation: 'Java泛型使用类型擦除，编译时保留类型信息并检查，运行时擦除类型信息。这是为了向后兼容，但也导致了一些限制，如不能使用基本类型作为泛型参数。'
	}
];

